const system = require('../../utils/system.js');

// 提交中页面
Page({
  data: {
    examId: '',
    mode: 'exam', // 默认是考试模式，可选值：exam, mistake
    result: null,
    formattedTime: '00:00:00',
    loading: true,  // 默认显示加载状态
    statusBarHeight: 0,
    navBarHeight: 44,
    bottomSafeHeight: 0,
    fixedContentMargin: '',
  },

  onLoad(options) {
    console.log('提交页面接收到的参数:', options);
    
    // 设置状态栏高度
    const statusBarHeight = system.statusBarHeight || 20;
    this.setData({
      statusBarHeight: statusBarHeight,
      navBarHeight: 44,
      // 计算固定内容边距以确保内容紧接导航栏
      fixedContentMargin: (statusBarHeight + 44) + 'px'
    });
    
    // 获取考试ID和模式（支持id和examId两种参数）
    const examId = options.examId || options.id || '';
    const mode = options.mode || 'exam';
    
    console.log('解析后的参数:', { examId, mode });
    
    this.setData({ 
      examId: examId,
      mode: mode
    });
    
    // 根据模式选择不同的存储键
    let storageKey;
    if (mode === 'mistake') {
      storageKey = 'mistakePracticeResults';
    } else if (mode === 'special') {
      storageKey = 'specialResults_' + examId;
    } else if (mode === 'home') {
      // 首页特殊处理
      storageKey = 'homeResults_' + examId;
    } else {
      storageKey = 'examResults_' + examId;
    }
    
    console.log('尝试从存储中获取:', storageKey);
    
    // 从本地存储获取考试结果
    let result = wx.getStorageSync(storageKey);
    console.log('获取到的结果:', result);
    
    // 如果没有找到结果，尝试从其他存储键获取
    if (!result || !Object.keys(result).length) {
      console.log('未找到结果，尝试从其他存储键获取');
      
      // 尝试所有可能的存储键
      const possibleKeys = [
        'examResults_' + examId,
        'specialResults_' + examId,
        'homeResults_' + examId
      ];
      
      for (const key of possibleKeys) {
        if (key === storageKey) continue; // 跳过已尝试的键
        
        const tempResult = wx.getStorageSync(key);
        if (tempResult && Object.keys(tempResult).length) {
          console.log('在存储键中找到结果:', key);
          result = tempResult;
          break;
        }
      }
    }
    
    // 如果是特殊模式但没有结果，尝试从其他地方获取
    if ((mode === 'special' || mode === 'home') && (!result || !Object.keys(result).length)) {
      console.log('特殊模式但没有找到结果，尝试获取模拟数据');
      this.loadMockExamResult(examId, mode);
      return;
    }
    
    // 处理结果数据
    if (result) {
      console.log('处理结果数据:', result);
      
      // 格式化正确率
      let correctRate = result.correctRate;
      if (typeof correctRate === 'string') {
        correctRate = parseFloat(correctRate);
      }
      if (correctRate > 1) {
        correctRate = correctRate / 100; // 如果是百分比形式(0-100)，转换为小数形式(0-1)
      }
      
      // 计算格式化的正确率文本
      const correctRateFormatted = Math.round(correctRate * 100);
      
      // 更新结果对象
      result.correctRate = correctRate;
      result.correctRateFormatted = correctRateFormatted;
      
      // 获取用时（优先使用duration，其次是timeUsed，最后是spendTime）
      const duration = result.duration || result.timeUsed || result.spendTime || 0;
      console.log('用时（秒）:', duration);
      
      // 格式化用时
      const formattedTime = this.formatTime(duration);
      console.log('格式化后的用时:', formattedTime);
      
      this.setData({
        result: result,
        formattedTime: formattedTime,
        loading: false
      });
    } else {
      console.error('未找到考试结果');
      wx.showToast({
        title: '未找到考试结果',
        icon: 'none'
      });
      this.setData({ loading: false });
    }
  },

  /**
   * 加载考试结果
   */
  loadExamResult(examId) {
    try {
      // 从本地存储获取考试结果
      const result = wx.getStorageSync('examResults_' + examId);
      console.log('获取到的考试结果:', result);
      
      if (result) {
        // 格式化时间显示
        const spendTime = result.spendTime || 0; // 单位：秒
        const formattedTime = this.formatTime(spendTime);
        
        this.setData({
          result: result,
          formattedTime: formattedTime,
          loading: false  // 加载完成，显示结果
        });
      } else {
        wx.showToast({
          title: '未找到考试结果',
          icon: 'none'
        });
        this.setData({ loading: false });
      }
    } catch (error) {
      console.error('加载考试结果出错:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setData({ loading: false });
    }
  },
  
  /**
   * 加载错题练习结果
   */
  loadMistakePracticeResult() {
    try {
      // 从本地存储获取错题练习结果
      const result = wx.getStorageSync('mistakePracticeResults');
      console.log('获取到的错题练习结果:', result);
      
      if (result) {
        // 格式化时间显示
        const spendTime = result.spendTime || 0; // 单位：秒
        const formattedTime = this.formatTime(spendTime);
        
        this.setData({
          result: result,
          formattedTime: formattedTime,
          loading: false  // 加载完成，显示结果
        });
      } else {
        wx.showToast({
          title: '未找到练习结果',
          icon: 'none'
        });
        this.setData({ loading: false });
      }
    } catch (error) {
      console.error('加载错题练习结果出错:', error);
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'none'
      });
      this.setData({ loading: false });
    }
  },

  formatTime(seconds) {
    // 确保输入是数字
    seconds = parseInt(seconds) || 0;
    
    // 如果是毫秒，转换为秒
    if (seconds > 1000000) {
      seconds = Math.floor(seconds / 1000);
    }
    
    const hours = Math.floor(seconds / 3600);
    const minutes = Math.floor((seconds % 3600) / 60);
    const secs = seconds % 60;
    
    if (hours > 0) {
      return `${hours}小时${minutes}分${secs}秒`;
    } else if (minutes > 0) {
      return `${minutes}分${secs}秒`;
    } else {
      return `${secs}秒`;
    }
  },

  reviewExam() {
    const { mode, examId, result } = this.data;
    
    console.log('点击查看解析按钮，准备跳转', { mode, examId, resultType: typeof result });
    
    // 添加提示，让用户知道正在处理
    wx.showLoading({
      title: '正在加载...',
      mask: true
    });
    
    // 保存结果到全局数据，以防页面间传递失败
    if (result) {
      try {
        const app = getApp();
        if (app.globalData) {
          app.globalData.currentExamResult = result;
          console.log('已将结果保存到全局数据');
        }
      } catch (e) {
        console.error('保存到全局数据失败:', e);
      }
    }
    
    // 构建URL，添加时间戳防止缓存
    let url = '';
    if (mode === 'mistake') {
      url = `/pages/result/index?examId=mistake_practice&mode=mistake&t=${Date.now()}`;
    } else if (mode === 'special') {
      // 专项模块特殊处理
      url = `/pages/result/index?examId=${examId}&mode=special&t=${Date.now()}`;
    } else {
      url = `/pages/result/index?examId=${examId}&t=${Date.now()}`;
    }
    
    console.log('准备跳转到:', url);
    
    // 检查页面栈
    const pages = getCurrentPages();
    console.log('当前页面栈:', pages.length);
    
    // 如果页面栈接近上限，使用redirectTo
    if (pages.length >= 8) {
      wx.redirectTo({
        url: url,
        success: () => {
          console.log('redirectTo跳转成功');
          wx.hideLoading();
        },
        fail: (error) => {
          console.error('redirectTo跳转失败:', error);
          this.fallbackNavigation(url);
        }
      });
    } else {
      // 否则使用navigateTo
      wx.navigateTo({
        url: url,
        success: () => {
          console.log('navigateTo跳转成功');
          wx.hideLoading();
        },
        fail: (error) => {
          console.error('navigateTo跳转失败:', error);
          this.fallbackNavigation(url);
        }
      });
    }
  },

  // 备用导航方法
  fallbackNavigation(url) {
    console.log('尝试备用导航方法');
    
    // 尝试使用reLaunch
    wx.reLaunch({
      url: url,
      success: () => {
        console.log('reLaunch跳转成功');
        wx.hideLoading();
      },
      fail: (err) => {
        console.error('所有跳转方式都失败');
        wx.hideLoading();
        
        // 最后尝试使用switchTab到首页
        wx.showToast({
          title: '跳转失败，请从首页重新进入',
          icon: 'none',
          duration: 2000
        });
        
        setTimeout(() => {
          wx.switchTab({
            url: '/pages/index/index'
          });
        }, 2000);
      }
    });
  },

  // 返回上一页
  goBack() {
    console.log('点击返回按钮');
    
    // 添加一个提示，确认函数被调用
    wx.showToast({
      title: '正在返回...',
      icon: 'none',
      duration: 1000
    });
    
    // 获取当前页面栈
    const pages = getCurrentPages();
    console.log('当前页面栈:', pages.length, pages);
    
    // 尝试直接返回上一页，不检查页面栈
    wx.navigateBack({
      delta: 1,
      success: () => {
        console.log('成功返回上一页');
      },
      fail: (error) => {
        console.error('返回上一页失败:', error);
        
        // 如果返回失败，尝试跳转到首页
        console.log('尝试跳转到首页');
        wx.switchTab({
          url: '/pages/index/index',
          success: () => {
            console.log('成功跳转到首页');
          },
          fail: (switchError) => {
            console.error('跳转到首页失败:', switchError);
            
            // 最后尝试使用reLaunch
            wx.reLaunch({
              url: '/pages/index/index'
            });
          }
        });
      }
    });
  },

  // 返回首页
  returnHome() {
    console.log('点击返回首页按钮');
    
    // 直接跳转到首页
    wx.switchTab({
      url: '/pages/index/index',
      success: () => {
        console.log('成功跳转到首页');
      },
      fail: (error) => {
        console.error('跳转到首页失败:', error);
        // 尝试使用reLaunch作为备选
        wx.reLaunch({
          url: '/pages/index/index'
        });
      }
    });
  },

  onShareAppMessage() {
    const { result, mode, examId } = this.data;
    if (!result) return {};
    
    if (mode === 'mistake') {
      // 错题练习分享
      return {
        title: `我在错题练习中答对了${result.correctNum}题，正确率${result.correctRate}%`,
        path: '/pages/mistakes/index',
        imageUrl: '/images/share-mistake.png'
      };
    } else {
      // 普通考试分享
      return {
        title: `我在「${result.examTitle}」中答对了${result.correctNum}题，正确率${result.correctRate}%`,
        path: `/pages/exam/index?examId=${examId}&mode=special`,
        imageUrl: '/images/share-bg.png'
      };
    }
  },

  // 再做一次
  tryAgain() {
    const { examId, mode } = this.data;
    console.log('再做一次，examId:', examId, 'mode:', mode);
    
    if (!examId) {
      wx.showToast({
        title: '无法获取试卷ID',
        icon: 'none'
      });
      return;
    }
    
    wx.navigateTo({
      url: `/pages/exam/index?examId=${examId}&mode=${mode || 'special'}`,
      success: () => {
        console.log('跳转成功');
      },
      fail: (error) => {
        console.error('跳转失败:', error);
        wx.showToast({
          title: '跳转失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  // 加载模拟考试结果（如果本地存储没有）
  loadMockExamResult(examId, mode) {
    console.log('加载模拟考试结果:', examId, mode);
    
    // 这里可以从API获取，但现在使用模拟数据
    const mockResult = {
      examId: examId,
      examTitle: mode === 'special' ? '专项练习 ' + examId : '模拟考试 ' + examId,
      totalQuestions: 10,
      correctCount: 7,
      wrongCount: 3,
      correctRate: 0.7,
      timeUsed: 600, // 10分钟
      answers: Array(10).fill().map((_, i) => ({
        id: i + 1,
        correct: i < 7, // 前7题正确，后3题错误
        userAnswer: String.fromCharCode(65 + Math.floor(Math.random() * 4)), // A, B, C, D
        correctAnswer: String.fromCharCode(65 + Math.floor(Math.random() * 4))
      }))
    };
    
    // 格式化正确率
    mockResult.correctRateFormatted = Math.round(mockResult.correctRate * 100);
    
    // 格式化用时
    const formattedTime = this.formatTime(mockResult.timeUsed || 0);
    
    // 保存到本地存储
    const storageKey = mode === 'special' 
      ? 'specialResults_' + examId 
      : 'homeResults_' + examId;
      
    try {
      wx.setStorageSync(storageKey, mockResult);
      console.log('已保存模拟考试结果到本地存储:', storageKey);
    } catch (e) {
      console.error('保存模拟考试结果失败:', e);
    }
    
    // 更新页面数据
    this.setData({
      result: mockResult,
      formattedTime: formattedTime,
      loading: false
    });
  }
}) 